Derivation of a Fast Integer Square Root Algorithm

In a constructive setting, the formula ∀n ∃r r2≤n ∧ n<(r+1) specifies an algorithm for computing the integer square root r of a natural number x. A proof for this formula implicitly contains an integer square root algorithm that mirrors the way in which the formula was proven correct. In this note we describe the formal derivation of several integer square root algorithms within the Nuprl proof development system and show how efficient algorithms can be derived using advanced induction schemes. 1 Deriving a Linear Algorithm The standard approach to proving ∀n ∃r r2≤n ∧ n<(r+1)2 is induction on n, which will lead to the following two proof goals Base Case: prove ∃r r2≤0 ∧ 0<(r+1)2 Induction Step: prove ∃r r2≤n+1 ∧ n+1<(r+1)2 assuming ∃rn r2≤n ∧ n<(rn+1). The base case can be solved by choosing r = 0 and using standard arithmetical reasoning to prove the resulting proof obligation 02≤0 ∧ 0<(0+1)2. In the induction step, one has to analyze the root rn. If (rn+1)≤n+1, then choosing r = rn+1 will solve the goal. Again, the proof obligation (rn+1)≤n+1 ∧ n+1<((rn+1)+1) can be shown by standard arithmetical reasoning. (rn+1) > n+1, then one has to choose r = rn and prove r2 n≤n+1 ∧ n+1<(rn+1) using standard arithmetical reasoning. Figure 1 shows the trace of a formal proof in the Nuprl system [CAB+86, ACE+00] that uses exactly this line of argument. It initiates the induction by applying the library theorem NatInd ∀P:N→P. (P(0) ∧ (∀i:N+. P(i-1) ⇒ P(i))) ⇒ (∀i:N. P(i)) The base case is solved by assigning 0 to the existentially quantified variable and using Nuprl’s autotactic (trivial standard reasoning) to deal with the remaining proof obligation. In the step case (from i−1 to i) it analyzes the root r for i−1, introduces a case distinction on (r+1)2≤i and then assigns either r or r+1, again using Nuprl’s autotactic on the rest of the proof. Nuprl is capable of extracting an algorithm from the formal proof, which then may be run within Nuprl’s computation environment or be exported to other programming systems. The algorithm is represented in Nuprl’s extended lambda calculus. Depending on the formalization of the existential quantifier there are two kinds of algorithms that may be extracted. In the standard formalization, where ∃ is represented as a (dependent)